<?xml version="1.0" encoding="UTF-8"?>
<html>
    <head>
        <link type="text/css" rel="stylesheet" href="./css/template.css" />
        <link type="text/css" rel="stylesheet" href="./css/SyntaxHighlighter.css" />
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <title>Eclipse UML</title>
        <script language="javascript" src="./js/shInit.js" />
        <script language="javascript" src="./js/shCore.js" />
        <script language="javascript" src="./js/shBrushCpp.js" />
        <script language="javascript" src="./js/shBrushCSharp.js" />
        <script language="javascript" src="./js/shBrushCss.js" />
        <script language="javascript" src="./js/shBrushDelphi.js" />
        <script language="javascript" src="./js/shBrushJava.js" />
        <script language="javascript" src="./js/shBrushJScript.js" />
        <script language="javascript" src="./js/shBrushPhp.js" />
        <script language="javascript" src="./js/shBrushPython.js" />
        <script language="javascript" src="./js/shBrushRuby.js" />
        <script language="javascript" src="./js/shBrushSql.js" />
        <script language="javascript" src="./js/shBrushVb.js" />
        <script language="javascript" src="./js/shBrushXml.js" />
        <keywords>Eclipse, UML, plugin,reverse engineering</keywords>
        <author>Julien Pastel</author>
    </head>
    <body>
        <div class="chapter">
            <h2>1.Introduction</h2>
            <div class="subChapter">
                <h3>1.1.Qu’est-ce qu’ EclipseUML ?</h3>
                <p>
                    EclipseUML d’Omondo est, comme son nom l’indique, un plugin pour Eclipse permettant de réaliser des diagrammes UML et les fonctionnalités de génération de code / reverse directement intégré à votre IDE.
					Le plugin EclipseUML est disponible en deux versions :
                    <br />
                    <br />
                    - EclipseUML Free Edition
                    <br />
                    - EclipseUML Studio Edition
                    <br />
                    <br />
                    Dans le cadre de cet article nous utiliserons la version gratuite.
                </p>
            </div>
            <div class="subChapter">
                <h3>1.2.Téléchargement et installation d’EclipseUML</h3>
                <h4>1.2.1.Téléchargement</h4>
                <p>
                    Avant toute chose il nous faut télécharger ce plugin. On le trouve à l’adresse suivante :
                    <br />
                    <br />
                    <a href="http://www.eclipsedownload.com/download/free/eclipse_3x/index.html" target="_blank">
                        <img src="./images/EclipseUML_html_m26b8a3a7.jpg" />
                    </a>
                </p>
                <h4>1.2.2.Installation</h4>
                <p>
                    Une fois le plugin téléchargé (un fichier Jar) il vous suffit de double cliquer pour le lancer automatiquement ou alors le lancer en ligne de commande :
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_44a4bfa8.jpg" />
                    <br />
                    Vous devriez obtenir l’écran suivant :
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_m28308a03.jpg" />
                    <br />
                    Lorsque le logiciel d’installation vous demandera dans quel répertoire vous souhaitez installer EclipseUML, vous devrez choisir le répertoire racine de votre Eclipse, sinon le plugin ne pourra pas être pris en compte. Vous pouvez comme dans l’exemple, sélectionner le dossier C:\eclipse\ :
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_m63096e12.jpg" />
                    <br />
                    <br />
                    Dans l’écran suivant, laissez tout coché par défaut, ce sont des plugins indispensables au bon fonctionnement d’EclipseUML. L’installeur se proposera alors d’installer tous les plugins requis si ceux-ci ont été sélectionnés, si vous ajoutez EclipseUML à un Eclipse possédant déjà ces plugins vous pouvez les désélectionner.
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_m2bdbff1b.jpg" />
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_10399bae.jpg" />
                    <br />
                    <br />
                    Maintenant que l’installation est terminée, nous pouvons passer au cas pratique.
                </p>
            </div>
        </div>
        <div class="chapter">
            <h2>2.Mise en œuvre</h2>
            <p>Dans cette partie nous allons étudier la mise en œuvre d’un simple diagramme de classe mais aussi la fonctionnalité de « reverse engineering » qui permet de créer les diagrammes UML à partir de classes déjà existantes.</p>
            <div class="subChapter">
                <h3>2.1.Diagramme de classe</h3>
                <h4>2.1.1.Création du projet</h4>
                <p>
                    Tout d’abord avant de créer un diagramme de classe, nous allons créer un nouveau projet dans Eclipse.
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_7e963a03.jpg" />
                    <br />
                    <br />
                    Dans cette présentation nous nommerons ce projet « umltest » mais libre à vous de le nommer comme vous le souhaitez.
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_m1f06b09e.jpg" />
                    <br />
                    <br />
                    Maintenant que le projet est créé nous allons créer un package
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_m80a1320.jpg" />
                    <br />
                    <br />
                    Dans cet exemple nous appellerons le package « demo »
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_663a748d.jpg" />
                </p>
                <h4>2.1.2.Création d’un diagramme de classe</h4>
                <p>
                    Maintenant que notre projet est bien créé, nous allons passer à la création de notre premier diagramme de classe. Nous pourrons grâce à ce diagramme générer automatiquement le code des classes. Nous le créerons dans le package « demo ». Pour se faire, nous ferons un clic-droit sur ce package et nous choisirons de créer un nouveau UML Class Diagram. Comme vous pouvez le constater, grâce à EclipseUML vous avez la possibilité de créer tous les types de diagramme UML possible (Use Case, Sequence, …). Dans le cadre de ce tutorial nous ne verrons que les diagrammes de classes.
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_66173653.jpg" />
                    <br />
                    <br />
                    Dans la fenêtre que vous obtenez il vous sera possible de donner le nom que vous souhaitez au diagramme et de définir quelques options :
                    <br />
                    <br />
                    - Association : afficher les différentes associations existantes entre les classes du diagramme
                    <br />
                    - Inheritance : afficher les relations d’héritage
                    <br />
                    - Dependency : afficher les relations d’importation entre les différentes classes.
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_d1cd2e1.jpg" />
                    <br />
                    <br />
                    Dans cet exemple nous nommons le diagramme « demo » et le plaçons dans le package demo
					Une fois terminé, l’environnement EclipseUML va se charger et vous pourrez maintenant créer vos classes, interfaces et différentes relations liant ces classes (association, héritage, dépendance …)
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_2692fa95.jpg" />
                </p>
                <h4>2.1.3.Création d’une classe</h4>
                <p>
                    Maintenant que nous avons notre projet et notre diagramme de classe de créés, nous allons voir comment créer une classe via l’environnement EclipseUML.
					Tout d’abord, vous avez deux possibilités :
                    <br />
                    <br />
                    - Passer par la barre d’outils
                    <br />
                    - Clic droit puis New… Class
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_m6ff92f0.jpg" />
                    <br />
                    <br />
                    Vous tombez alors sur la fenêtre de création de classe par défaut d’Eclipse.
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_7011a644.jpg" />
                    <br />
                    <br />
                    Une fois votre classe créée vous remarquerez que non seulement votre diagramme de classe contient la classe, mais que vous pouvez aussi modifier directement le code de votre classe.
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_47832ac1.jpg" />
                    <br />
                    <br />
                    Maintenant vous pouvez ajouter à cette classe :
                    <br />
                    <br />
                    - des attributs
                    <br />
                    - des méthodes
                    <br />
                    - des classes internes
                    <br />
                    - ou des interfaces internes
                    <br />
                    <br />
                    Pour se faire : clic droit sur la classe créée puis vous choisissez ce qui vous intéresse.
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_3cd49e46.jpg" />
                    <br />
                    <br />
                    Dans un premier temps on ajoutera un attribut « name » privé de type String ayant des accesseurs (getName() et setName()). Dans la fenêtre qui s’affiche vous trouvez toutes les options nécessaires à la définitions de votre attribut. Il est possible de choisir la visibilité de votre attribut, les modificateurs, et si vous souhaitez ou non utiliser des accesseurs (get et set ou la méthode en « read only ») et leur indicateur de visibilité.
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_3789074c.jpg" />
                    <br />
                    <br />
                    <u>Rappel</u>
                    : Un accesseur est une méthode publique qui permet d’accéder à une variable d’instance privée
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_m3a5a1aed.jpg" />
                    <br />
                    <br />
                    Ici, dans la définition UML de la classe nous ne verrons pas directement les accesseurs. En effet, par défaut l’environnement Eclipse UML utilise le concept de propriété (une propriété publique correspond à un attribut privé et l'(es) accesseur(s) correspondant(s)). Si vous souhaitez quand même avoir le détail de votre classe, vous pouvez désactiver cette fonction en allant dans les préférences de votre classe via un clic droit puis Préférences.
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_43e49355.jpg" />
                    <br />
                    <br />
                    Vous avez aussi la possibilité de changer les options de visibilité dans le diagramme de vos différents attributs et méthodes. A vous de voir ce qui vous intéresse.
					Par le même moyen vous pouvez aussi ajouter des méthodes et constructeurs aussi facilement que pour les attributs.
                </p>
                <p />
            </div>
            <div class="subChapter">
                <h3>2.2.Reverse Engineering (rétro conception)</h3>
                <p>
                    Grâce à ce plugin, vous avez la possibilité de créer des diagrammes UML à partir d’un projet déjà existant package par package.
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_m36b31eaa.jpg" />
                    <br />
                    <br />
                    Afin de pouvoir procéder à la rétro-conception de notre projet existant, nous allons faire un clic droit sur ce projet puis UML puis Reverse engineering. Au cas où vous avez déjà des annotations UML dans votre projet, vous avez la possibilité de les supprimer via la fonction Clean pour plus de clarté dans votre projet mais aussi si vous n’avez pas besoin de commentaires UML dans votre JavaDoc.
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_7b4d1277.jpg" />
                    <br />
                    <br />
                    Dans la fenêtre qui s’affiche vous cochez votre projet et ne tenez pas compte du warning. Vous pouvez maintenant procéder à la rétro conception du projet.
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_166b6c81.jpg" />
                    <br />
                    <br />
                    Vous obtenez maintenant le diagramme représentant les différents packages de votre projet. Maintenant pour obtenir les classes, vous devez double cliquer sur le package
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_m7ffa0d32.jpg" />
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_m1ca5f66d.jpg" />
                    <br />
                    <br />
                    Dans cette fenêtre vous choisissez les options de lien et de portée souhaitées.
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_58493c9c.jpg" />
                    <br />
                    <br />
                    Ensuite, il vous sera demandé de choisir les classes que vous souhaitez inclure dans le diagramme.
					Enfin, vous obtenez le diagramme de classe. Dans cet exemple, EclipseUML a créé automatiquement des relations entre les deux classes : une dépendance (importation de la classe Animal) et une association. En effet, ici la classe zoo contient une ArrayList d’animaux (classe Animal)
                    <br />
                    <br />
                    <img src="./images/EclipseUML_html_m49cb7ce.jpg" />
                </p>
                <p />
            </div>
        </div>
    </body>
</html>

